# # 设计一个对海量数据文本排序的程序
# # 需求：1、启动程序打开dos命令窗口 2、拖动要排序的文本到运行的程序
# # 3、生成已经排序完成的文件 4、统计相同日期条目数并且生成统计文件
#
# import os
# import sys
# import os
#
# def main():
#     # 检查是否通过拖放传递了文件
#     if len(sys.argv) < 2:
#         print("请将一个 .txt 文件拖放到本程序 (.exe) 上以进行排序。")
#         input("按 Enter 键退出...")
#         return
#
#     input_file_path = sys.argv[1]
#
#     # 确保输入文件存在
#     if not os.path.isfile(input_file_path):
#         print(f"错误: 找不到文件 '{input_file_path}'")
#         input("按 Enter 键退出...")
#         return
#
#     # 确定输出文件路径 (源文件名 + _sorted.txt)
#     input_dir = os.path.dirname(input_file_path)
#     input_filename = os.path.basename(input_file_path)
#     # 分离文件名和扩展名，然后构造新的文件名
#     input_name, input_ext = os.path.splitext(input_filename)
#     output_filename = f"{input_name}_sorted{input_ext}"
#     output_file_path = os.path.join(input_dir, output_filename)
#
#     try:
#         # 1. 获取用户输入的排序列号
#         print(f"检测到文件: {input_file_path}")
#         while True:
#             try:
#                 col_num_input = input("请输入要排序的字段编号 (从 1 开始): ")
#                 sort_column_index = int(col_num_input) - 1
#                 if sort_column_index < 0:
#                     raise ValueError("列号必须大于0")
#                 break
#             except ValueError:
#                 print("输入无效，请输入一个正整数。")
#
#         delimiter = '|'  # 指定分隔符
#
#         # 2. 一次性读取所有行到内存
#         print("正在读取文件到内存...")
#         with open(input_file_path, 'r', encoding='utf-8') as f:
#             lines = f.readlines()
#
#         total_lines = len(lines)
#         print(f"文件读取完成，共 {total_lines} 行。")
#
#         # 3. 定义排序键函数
#         # 处理字段不存在的行，将其排在最后
#         max_split_parts = sort_column_index + 2 # 预估最大分割部分数以优化
#
#         def sort_key(line):
#             parts = line.split(delimiter, max_split_parts)
#             # 如果字段不存在，返回一个排在最后的键
#             if len(parts) <= sort_column_index:
#                  # 假设正常字段不会以这个特殊字符串开头
#                 return "~" * 100
#             return parts[sort_column_index]
#
#         # 4. 在内存中排序
#         print("正在对数据进行排序...")
#         sorted_lines = sorted(lines, key=sort_key)
#         print("排序完成。")
#
#         # 5. 写入输出文件
#         print(f"正在写入排序结果到 '{output_filename}'...")
#         with open(output_file_path, 'w', encoding='utf-8') as f:
#             f.writelines(sorted_lines)
#         print(f"处理完成！排序结果已保存到: {output_file_path}")
#
#     except MemoryError:
#         print("\n错误: 内存不足，无法一次性加载整个文件。")
#         print("请考虑使用支持分块处理的版本，或在内存更大的机器上运行。")
#     except Exception as e:
#         print(f"\n处理文件时发生未预期的错误: {e}")
#
#     # 防止控制台窗口立即关闭
#     input("\n按 Enter 键退出...")
#
# if __name__ == "__main__":
#     main()
#


# import sys
# import os
#
# def main():
#     if len(sys.argv) < 2:
#         print("请将一个 .txt 文件拖放到本程序 (.exe) 上以进行排序。")
#         input("按 Enter 键退出...")
#         return
#
#     input_file_path = sys.argv[1]
#
#     if not os.path.isfile(input_file_path):
#         print(f"错误: 找不到文件 '{input_file_path}'")
#         input("按 Enter 键退出...")
#         return
#
#     input_dir = os.path.dirname(input_file_path)
#     input_filename = os.path.basename(input_file_path)
#     input_name, input_ext = os.path.splitext(input_filename)
#     output_filename = f"{input_name}_sorted{input_ext}"
#     output_file_path = os.path.join(input_dir, output_filename)
#     stat_output_filename = f"{input_name}_sorted_stats.txt"
#     stat_output_path = os.path.join(input_dir, stat_output_filename)
#
#     try:
#         print(f"检测到文件: {input_file_path}")
#         while True:
#             try:
#                 col_num_input = input("请输入要排序的字段编号 (从 1 开始): ")
#                 sort_column_index = int(col_num_input) - 1
#                 if sort_column_index < 0:
#                     raise ValueError("列号必须大于0")
#                 break
#             except ValueError:
#                 print("输入无效，请输入一个正整数。")
#
#         delimiter = '|'
#
#         print("正在读取文件到内存...")
#         with open(input_file_path, 'r', encoding='utf-8') as f:
#             lines = f.readlines()
#         total_lines = len(lines)
#         print(f"文件读取完成，共 {total_lines} 行。")
#
#         max_split_parts = sort_column_index + 2
#
#         def sort_key(line):
#             parts = line.split(delimiter, max_split_parts)
#             # 直接提取字段（假设字段存在）
#             return parts[sort_column_index]
#
#         print("正在对数据进行排序...")
#         sorted_lines = sorted(lines, key=sort_key)
#         print("排序完成。")
#
#         print(f"正在写入排序结果到 '{output_filename}'...")
#         with open(output_file_path, 'w', encoding='utf-8') as f:
#             f.writelines(sorted_lines)
#         print(f"处理完成！排序结果已保存到: {output_file_path}")
#
#         # 新增：统计字段出现次数
#         print("正在统计字段出现次数...")
#         unique_keys = []
#         statistics = {}
#         for line in sorted_lines:
#             key = sort_key(line)
#             if key not in statistics:
#                 unique_keys.append(key)
#                 statistics[key] = 1
#             else:
#                 statistics[key] += 1
#
#         stat_lines = [f"{key},{count}\n" for key, count in statistics.items()]
#
#         with open(stat_output_path, 'w', encoding='utf-8') as f:
#             f.writelines(stat_lines)
#         print(f"统计文件已生成，保存到: {stat_output_path}")
#
#     except MemoryError:
#         print("\n错误: 内存不足，无法一次性加载整个文件。")
#         print("请考虑使用支持分块处理的版本，或在内存更大的机器上运行。")
#     except Exception as e:
#         print(f"\n处理文件时发生未预期的错误: {e}")
#
#     input("\n按 Enter 键退出...")
#
# if __name__ == "__main__":
#     main()


# import sys
# import os
#
# def main():
#     if len(sys.argv) < 2:
#         print("请将一个 .txt 文件拖放到本程序 (.exe) 上以进行排序。")
#         input("按 Enter 键退出...")
#         return
#
#     input_file_path = sys.argv[1]
#
#     if not os.path.isfile(input_file_path):
#         print(f"错误: 找不到文件 '{input_file_path}'")
#         input("按 Enter 键退出...")
#         return
#
#     input_dir = os.path.dirname(input_file_path)
#     input_filename = os.path.basename(input_file_path)
#     input_name, input_ext = os.path.splitext(input_filename)
#     output_filename = f"{input_name}_sorted{input_ext}"
#     output_file_path = os.path.join(input_dir, output_filename)
#     stat_output_filename = f"{input_name}_sorted_stats.txt"
#     stat_output_path = os.path.join(input_dir, stat_output_filename)
#
#     try:
#         print(f"检测到文件: {input_file_path}")
#         while True:
#             try:
#                 col_num_input = input("请输入要排序的字段编号 (从 1 开始): ")
#                 sort_column_index = int(col_num_input) - 1
#                 if sort_column_index < 0:
#                     raise ValueError("列号必须大于0")
#                 break
#             except ValueError:
#                 print("输入无效，请输入一个正整数。")
#
#         delimiter = '|'
#
#         print("正在读取文件到内存...")
#         with open(input_file_path, 'r', encoding='utf-8') as f:
#             lines = f.readlines()
#         total_lines = len(lines)
#         print(f"文件读取完成，共 {total_lines} 行。")
#
#         # 移除 max_split_parts，直接使用 strip() 避免换行符影响
#         def sort_key(line):
#             line_stripped = line.strip()  # 去除首尾空白字符和换行符
#             parts = line_stripped.split(delimiter)
#             # ✅ 关键修复：检查索引是否越界
#             if sort_column_index >= len(parts):
#                 return ""  # 返回空字符串作为默认值，确保能排序且不报错
#             return parts[sort_column_index]
#
#         print("正在对数据进行排序...")
#         sorted_lines = sorted(lines, key=sort_key)
#         print("排序完成。")
#
#         # print(f"正在写入排序结果到 '{output_filename}'...")
#         # with open(output_file_path, 'w', encoding='utf-8') as f:
#         #     f.writelines(sorted_lines)
#         # print(f"处理完成！排序结果已保存到: {output_file_path}")
#
#         # 新增：统计字段出现次数
#         print("正在统计字段出现次数...")
#         unique_keys = []
#         statistics = {}
#         for line in sorted_lines:
#             key = sort_key(line)
#             # 可选：跳过空值（即原文件中字段缺失的行）
#             # if key == "":
#             #     continue
#             if key not in statistics:
#                 unique_keys.append(key)
#                 statistics[key] = 1
#             else:
#                 statistics[key] += 1
#
#         # 生成统计文件内容
#         stat_lines = [f"{key},{count}\n" for key, count in statistics.items()]
#
#         with open(stat_output_path, 'w', encoding='utf-8') as f:
#             f.writelines(stat_lines)
#         print(f"统计文件已生成，保存到: {stat_output_path}")
#
#     except MemoryError:
#         print("\n错误: 内存不足，无法一次性加载整个文件。")
#         print("请考虑使用支持分块处理的版本，或在内存更大的机器上运行。")
#     except Exception as e:
#         # 捕获并打印更详细的错误信息
#         print(f"\n处理文件时发生未预期的错误: {e}")
#         import traceback
#         traceback.print_exc()  # 打印完整的错误堆栈，便于调试
#
#     input("\n按 Enter 键退出...")
#
# if __name__ == "__main__":
#     main()

# 优化对多个文件进行日期统计

import sys
import os

statistics = {}

def process_file(input_file_path, sort_column_index):
    """处理单个文件：排序并生成统计文件"""
    input_dir = os.path.dirname(input_file_path)
    input_filename = os.path.basename(input_file_path)
    input_name, input_ext = os.path.splitext(input_filename)

    # 生成输出文件名
    output_filename = f"{input_name}_sorted{input_ext}"
    # output_file_path = os.path.join(input_dir, output_filename)
    stat_output_filename = f"{input_name}_sorted_stats.txt"
    # stat_output_path = os.path.join(input_dir, stat_output_filename)

    try:
        print(f"\n正在处理文件: {input_file_path}")
        # 读取文件
        with open(input_file_path, 'r', encoding='utf-8') as f:
            lines = f.readlines()
        total_lines = len(lines)
        print(f"文件读取完成，共 {total_lines} 行。")

        # 排序函数（关键修复：处理索引越界）
        def sort_key(line):
            line_stripped = line.strip()
            parts = line_stripped.split('|')
            if sort_column_index >= len(parts):
                return ""  # 越界时返回空字符串
            return parts[sort_column_index]

        # 排序
        sorted_lines = sorted(lines, key=sort_key)


        # 生成统计文件

        for line in sorted_lines:
            key = sort_key(line)
            if key == "":  # 跳过空值
                continue
            statistics[key] = statistics.get(key, 0) + 1
        print("统计完成。")

    except MemoryError:
        print(f"错误: 内存不足处理文件 '{input_file_path}'")
    except Exception as e:
        print(f"处理文件 '{input_file_path}' 时出错: {str(e)}")
        import traceback
        traceback.print_exc()


def main():
    # 检查是否有文件参数
    if len(sys.argv) < 2:
        print("请将一个或多个文件拖放到本程序 (.exe) 上以进行日期统计。")
        input("按 Enter 键退出...")
        return

    # 获取所有输入文件路径
    input_files = sys.argv[1:]
    valid_files = [f for f in input_files if os.path.isfile(f)]
    #
    if not valid_files:
        print("错误: 没有有效的文件")
        # print("请确保拖放的是 .txt 文件")
        input("按 Enter 键退出...")
        return

    # 提示用户输入排序列号（只输入一次）
    while True:
        try:
            col_num_input = input("\n请输入要排序的字段编号 (从 1 开始): ")
            sort_column_index = int(col_num_input) - 1
            if sort_column_index < 0:
                raise ValueError("列号必须大于0")
            break
        except ValueError:
            print("输入无效，请输入一个正整数。")

    # 处理每个文件
    print(f"\n将使用列 {sort_column_index + 1} 进行排序")
    for file_path in valid_files:
        process_file(file_path, sort_column_index)

    """处理单个文件：排序并生成统计文件"""
    input_dir = os.path.dirname(file_path)
    input_filename = os.path.basename(file_path)
    input_name, input_ext = os.path.splitext(input_filename)

    # 生成输出文件名
    output_filename = f"{input_name}_sorted{input_ext}"
    output_file_path = os.path.join(input_dir, output_filename)
    stat_output_filename = f"{input_name}_sorted_stats.txt"
    stat_output_path = os.path.join(input_dir, stat_output_filename)

    # 写入统计文件
    with open(stat_output_path, 'w', encoding='utf-8') as f:
        for key, count in sorted(statistics.items()):
            f.write(f"{key},{count}\n")
    print(f"统计文件已生成: {stat_output_path}")

    print("\n所有文件处理完成！")
    input("按 Enter 键退出...")


if __name__ == "__main__":
    main()



